package com.rxmvp.rxmvpdemo.activity;

import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.TextView;

import com.rxmvp.rxmvpdemo.App;
import com.rxmvp.rxmvpdemo.R;
import com.rxmvp.rxmvpdemo.RxBus.Events;
import com.rxmvp.rxmvpdemo.RxBus.RxBus;
import com.rxmvp.rxmvpdemo.RxRetrofit.NetApi;
import com.rxmvp.rxmvpdemo.RxRetrofit.Response.BaseResponse;
import com.rxmvp.rxmvpdemo.RxRetrofit.RxRetrofitUtils;
import com.rxmvp.rxmvpdemo.RxRetrofit.subscriber.BaseSubscriber;
import com.rxmvp.rxmvpdemo.base.BaseActivity;
import com.rxmvp.rxmvpdemo.bean.NewsBean;
import com.trello.rxlifecycle.ActivityEvent;

import javax.inject.Inject;

import butterknife.BindView;
import rx.functions.Action1;
import rx.functions.Func1;

/**
 * 作者： huangRZ on 2017/1/21. 15:04
 * 邮箱：917647409@qq.com
 */
public class SecondActivity extends BaseActivity {

    @BindView(R.id.tv_second)
    TextView textView;

    @Inject
    RxRetrofitUtils rxRetrofit;
    @Inject
    NetApi netApi;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        //全局的依赖注入
        App.getGlobalComponent().inject(this);

        //在事件总线上订阅一个事件
        subscribe();

        //利用leakCanary检测是否发生内存泄漏
        App.getRefWatcher(getApplication()).watch(this);
    }

    private void subscribe() {
        RxBus.with(this)
                //设置subscriber跟随activity的destroy状态发生而解绑，避免subscriber的内存泄漏
                .setLifecycleEvent(ActivityEvent.DESTROY)
                //设置观察“事件总线”上的事件类型
                .setEvent(Events.TAP)
                //处理可能发生的错误
                .onError(new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        /**
                         * 笔记： 如果有异常发生，那么subscriber就会自动取消订阅，不再观察到事件的发生
                         */
                        Log.e("tag", "t : " + throwable.getMessage());
                        showShortToast(throwable.getMessage());
                    }
                })
                //当该subscriber观察的事件发生时，会将事件的结果在这里处理
                .onNext(new Action1<Events<?>>() {
                    @Override
                    public void call(Events<?> events) {
//                        NewsBean newsBean = (NewsBean) events.getContent();
//                        textView.setText(newsBean.toString());
                        textView.setText((String) events.getContent());
                    }
                })
                .create();
    }

    //发送一个事件
    public void sendEvent(View view) {
        //利用retrofit+RxJava完成网络异步访问获取数据
        rxRetrofit.setLifecycleEvent(ActivityEvent.DESTROY)
                .getObservable(netApi.getJson("yule", "004a2b29ab3245fdfb95ed25e590cc2b"), this)
                .map(new Func1<BaseResponse<NewsBean>, String>() {
                    @Override
                    public String call(BaseResponse<NewsBean> newsBeanBaseResponse) {
                        //将网络获取的数据转换成一个泛型为String的observer，传递下去
                        return newsBeanBaseResponse.getResult().getData().get(0).toString();
                    }
                })
                .subscribe(new BaseSubscriber<String>() {

                    //获取observer的String泛型的数据
                    @Override
                   public void onNext(String s) {

                        //创建一个事件对象，包括事件类型和事件内容（数据）
                        Events<String> stringEvents = new Events<>();
                        stringEvents.setCode(Events.TAP);
                        stringEvents.setContent(s);
                        //将事件发送到事件总线上，订阅了该事件的subscriber将会观察到到该数据
                        RxBus.getInstance().send(stringEvents);
                    }
                });
    }
}
